/***************************************************************************
 *   Copyright (C) 2004 by cyril dupuit                                    *
 *   cyrildupuit@hotmail.com                                               *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

//*****************************************************************************
// Nom du module : idt.c
// Description : Gestion des vecteurs d'interruptions
//*****************************************************************************
 
// Historique :
// 28/10/04 : Creation du module V1.0  

#include "Kernel/Core.h"
#include "Kernel/Errors.h"
#include "Arch/Pentium/Kernel/Cpu.h"
#include "Arch/Pentium/Kernel/Idt.h"

//*****************************************************************************
// Definition des equivalences :
//*****************************************************************************
#define IDTSIZE		256	// nombre max. de descripteurs dans la table

//*****************************************************************************
// Variable globales a ce module :
//*****************************************************************************
/* table de IDT */
static struct IdtGate Idt[IDTSIZE];

//*****************************************************************************
// Prototypes des procedures externes :
//*****************************************************************************
void AsmDefaultIntProc(void);
void AsmDivideErrorProc(void);
void AsmDebugProc(void);
void AsmNmiProc(void);
void AsmBreakPointProc(void);
void AsmOverflowProc(void);
void AsmBoundRangeExceededProc(void);
void AsmInvalideOpcode(void);
void AsmDeviceNotAvailaibleProc(void);
void AsmDoubleFaultProc(void);
void AsmCoprocessorOverrun(void);
void AsmIntelReserved1Proc(void);
void AsmFloatingPointErrorProc(void);
void AsmMachineCheckProc(void);
void AsmIntelReservedProc(void);
void AsmInvalideTssProc(void);
void AsmSegmentNotPresentProc(void);
void AsmStackSegmentFaultProc(void);
void AsmGeneralProtectionProc(void);
void AsmPageFault(void);
void AsmAlignementCheckProc(void);
void AsmSimdFloatingPointProc(void);

//*****************************************************************************
// Prototypes des fonctions/procedures de ce module
//*****************************************************************************
static void EnableIrq(int IntNo);
static void DisableIrq(int IntNo);

//*****************************************************************************
// Corps des fonctions/procedures
//*****************************************************************************

//*****************************************************************************
// But de la fonction : Installer un vecteur d'interruption
// Entrees :
//	IntNo : Numero du vecteur d'interruption
//	pProc : Adresse de la procedure a eAsmDefaultIntProcxecuter
// Sortie : Aucune
//*****************************************************************************
Status_t SetIntVector(int IntNo, void * pProc)
{
	struct IdtGate * pGate = &Idt[IntNo];

	if((IntNo < 0)||(IntNo >= IDTSIZE))
	{
		SetLastError(INCORRECT_INTERRUPT_VECTOR);
		return ERROR;
	}

	if(pProc == NULL)
	{
		DisableIrq(IntNo);//Desactiver la ligne d'IRQ
		pGate->Offset0_15 = (unsigned short)0;
		pGate->Offset16_31 = (unsigned short)0;
		pGate->Present = 0;
		pGate->Dpl = 0;
	}
	else
	{
		EnableIrq(IntNo);//Activer la ligne d'IRQ
		pGate->Offset0_15 = (unsigned short)((unsigned long)pProc & 0xFFFF);
		pGate->Offset16_31 = (unsigned short)((unsigned long)pProc >> 16);
		pGate->Present = 1;
		pGate->Dpl = 0;
	}

	return TRUE;
}

//*****************************************************************************
// But de la procedure : Activer une ligne d'IRQ en fonction du numero
// d'interruption
// Entree :
//	IntNo : Numero d'interruption
// Sortie : Auxcune
//*****************************************************************************
static void EnableIrq(int IntNo)
{
	int IrqNum;
	
	if(IntNo < 0x20) return;
	
	if(IntNo >= 0x32) return;
	
	IrqNum = IntNo - 0x20;
	
	if(IrqNum < 8)
	{//IRQ sur le PIC maitre
		OutByte(0x20 + 1, (InByte(0x20 + 1) & ~(1 << IrqNum)));
	}
	else
	{//IRQ sur le PIC esclave
		OutByte(0XA0 + 1, (InByte(0xA0 + 1) & ~(1 << (IrqNum - 8))));
	}
}

//*****************************************************************************
// But de la procedure : Desactiver une ligne d'IRQ en fonction du numero
// d'interruption
// Entree :
//	IntNo : Numero d'interruption
// Sortie : Aucune
//*****************************************************************************
static void DisableIrq(int IntNo)
{
	int IrqNum;
	
	if(IntNo < 0x20) return;
	
	if(IntNo >= 0x32) return;
	
	IrqNum = IntNo - 0x20;
	
	if(IrqNum < 8)
	{//IRQ sur le PIC maitre
		OutByte(0x20 + 1, (InByte(0x20 + 1) | (1 << IrqNum)));
	}
	else
	{//IRQ sur le PIC esclave
		OutByte(0xA0 + 1, (InByte(0XA0 + 1) | (1 << (IrqNum - 8))));
	}
}

//*****************************************************************************
// But de la fonction : Recuperer la procedure d'interruption associe a un
// vecteur
// Entree : 
//	IntNo : Numero du vecteur d'interruption
// Parametre retourne : Pointeur sur la procedure d'interruption, NULL si
// absente
//*****************************************************************************
Status_t GetIntVector(int IntNo, void * * pProc)
{
	unsigned long Offset;
	struct IdtGate * pGate = &Idt[IntNo];
	
	if((IntNo < 0)||(IntNo >= IDTSIZE))
	{
		SetLastError(INCORRECT_INTERRUPT_VECTOR);
		return ERROR;
	}

	if(pProc == NULL)
	{
		SetLastError(INCORRECT_PARAMETER_2);
		return ERROR;
	}

	Offset = (unsigned long)(pGate->Offset16_31 << 16);
	Offset += (unsigned long)pGate->Offset0_15;

	*pProc = (void *)Offset;

	return TRUE;
}


//*****************************************************************************
// But de la procedure : Initialiser l'IDT
// Entree : Aucune
// Sortie : Aucune
//*****************************************************************************
void InitIdt(void)
{
	struct Idtr Idtr;
	struct IdtGate * pGate;
	int I;

	/* initialisation des descripteurs systeme */
	for(I = 0; I < IDTSIZE; I++)
	{
		pGate = &Idt[I];

		pGate->Selector = BUILD_SEGMENT_REG_VALUE(0, FALSE, 1);
		pGate->Reserved = 0;
		pGate->Flags = 0;
		pGate->Type = 0x6;//IDT GATE
		pGate->OpSize = 1;
		pGate->Zero = 0;
		//Definir les ISR par defaut
		SetIntVector(I, NULL);
	}

	/* initialisation de la structure pour IDTR */
	Idtr.Base = (unsigned long)Idt;
	Idtr.Limit = sizeof(Idt) - 1;

	/* chargement du registre IDTR */
	asm volatile ("lidt %0\n"::"m"(Idtr):"memory");
	
	//Initialisation de l'IDT avec ces vecteurs par defaut	
	SetIntVector(0, DivideErrorProc);
	SetIntVector(1, DebugProc);
	SetIntVector(2, NmiProc);
	SetIntVector(3, BreakPointProc);
	SetIntVector(4, OverflowProc);
	SetIntVector(5, BoundRangeExceededProc);
	SetIntVector(6, InvalideOpcode);
	SetIntVector(7, DeviceNotAvailaibleProc);
	SetIntVector(8, DoubleFaultProc);
	SetIntVector(9, CoprocessorOverrun);
	SetIntVector(10, InvalideTssProc);
	SetIntVector(11, SegmentNotPresentProc);
	SetIntVector(12, StackSegmentFaultProc);
	SetIntVector(13, GeneralProtectionProc);
	SetIntVector(14, AsmPageFault);
	
	SetIntVector(15, IntelReservedProc);
	
	SetIntVector(16, FloatingPointErrorProc);
	SetIntVector(17, AlignementCheckProc);
	SetIntVector(18, MachineCheckProc);
	SetIntVector(19, SimdFloatingPointProc);

	for(I = 20; I < 256; I++) 
	{
		SetIntVector(I, DefaultInt);
	}
}

//*****************************************************************************
